/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.cip.esymons.tramite.beans;

import cip.util.ControladorAbstracto;

import org.richfaces.model.selection.SimpleSelection;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import javax.faces.model.SelectItem;
import org.cip.esymons.general.be.Area;
import org.cip.esymons.general.be.Cargo;
import org.cip.esymons.tesoreria.be.CuentaIngreso;
import org.cip.esymons.tramite.bc.AreaDelegate;
import org.cip.esymons.tramite.bc.CargoDelegate;
import org.cip.esymons.tramite.bc.CuentIngresoTraDelegate;
import org.cip.esymons.tramite.bc.CuentaIngresoDelegate;
import org.cip.esymons.tramite.bc.DocRequeridoDelegate;
import org.cip.esymons.tramite.bc.ProcedimientoDelegate;
import org.cip.esymons.tramite.bc.ResponsableProcDelegate;
import org.cip.esymons.tramite.bc.TipoDocumentoDelegate;
import org.cip.esymons.tramite.bc.TramiteDelegate;
import org.cip.esymons.tramite.be.CuentaingresoTramite;
import org.cip.esymons.tramite.be.DocRequerido;
import org.cip.esymons.tramite.be.EnumTipoTramite;
import org.cip.esymons.tramite.be.Operacion;
import org.cip.esymons.tramite.be.Procedimiento;
import org.cip.esymons.tramite.be.ResponsableProc;
import org.cip.esymons.tramite.be.TipoDocumento;
import org.cip.esymons.tramite.be.Tramite;
import org.cip.esymons.tramite.be.Transaccion;

/**
 *
 * @author Freddy Infantes
 */
public class TramiteController extends ControladorAbstracto {

    private TramiteDelegate delegado;
    private CuentIngresoTraDelegate ciTramiteDelegado;
    private ProcedimientoDelegate delegadoProc;
    private TipoDocumentoDelegate delegadoTDoc;
    private DocRequeridoDelegate delegadoDocR;
    private CargoDelegate delegadoCargo;
    private AreaDelegate areaDelegado;
    private ResponsableProcDelegate delegadoResp;
    private CuentaIngresoDelegate cuentaIngresoDeleg;
    private Tramite tramite;
    private EnumTipoTramite tipoTramiteSeleccionado;
    private String desc;
    private Procedimiento procedimiento;
    private List<CuentaingresoTramite> ciTramites;
    private Area areaPadre;
    private Area areaSeleccionada;
    private List<Area> areas;
    private List<Area> areasAgregadas;
    private List<Area> areasGrabar;
    private List<Area> areasEliminar;
    private SimpleSelection areaSelecionadas;
    private SimpleSelection areaSelecionadasAg;
    private SimpleSelection tipDocSelecionadas;
    private SimpleSelection tipDocSelecionadasAg;
    private List<Tramite> tramites;
    private List<Tramite> tramitesCargar;
    private List<Procedimiento> procedimientos;
    private List<CuentaIngreso> cuentaIngresos;
    private List<CuentaIngreso> cuentaIngresosAgregados;
    private List<DocRequerido> docRequeridos;
    private List<String> errores;
    private String descTDoc;
    private TipoDocumento tipoDocumento;
    private List<TipoDocumento> tipoDocumentos;
    private List<TipoDocumento> tipoDocumentosAgregados;
    private int codigo;
    private int contador;
    private String url;
    private boolean costo;
    private boolean modalAceptar;
    private boolean modalCargar;
    private boolean eliminados;
    private boolean editar;

    public TramiteController() {
        inicializar();
    }

    private void inicializar() {
        tramite=new Tramite();
        delegado = new TramiteDelegate();
        delegadoProc = new ProcedimientoDelegate();
        delegadoTDoc = new TipoDocumentoDelegate();
        delegadoDocR = new DocRequeridoDelegate();
        areaDelegado = new AreaDelegate();
        delegadoResp = new ResponsableProcDelegate();
        cuentaIngresoDeleg = new CuentaIngresoDelegate();
        ciTramiteDelegado = new CuentIngresoTraDelegate();
        descTDoc = "";
        tipoDocumento = new TipoDocumento();
    }

    public TramiteDelegate getDelegado() {
        return delegado;
    }

    public void setDelegado(TramiteDelegate delegado) {
        this.delegado = delegado;
    }

    public Tramite getTramite() {
        return tramite;
    }

    public void setTramite(Tramite tramite) {
        this.tramite = tramite;
    }

    public SelectItem[] getTipoTramiteItems() {
        try {
            SelectItem[] select = new SelectItem[EnumTipoTramite.values().length];
            int cont = 0;
            for (EnumTipoTramite e : EnumTipoTramite.values()) {
                select[cont] = new SelectItem(e, e.name());
                cont++;
            }
            return select;
        } catch (Exception ex) {
            SelectItem[] select = new SelectItem[1];
            select[0] = new SelectItem(null, "No existen Tipos");
            return select;
        }
    }

    public SelectItem[] getTramiteItems() {
        try {
            List<Tramite> la = delegado.findAll();
            SelectItem[] select = new SelectItem[la.size()];
            int i = 0;
            for (Tramite ev : la) {
                SelectItem item = new SelectItem(ev.getTrmCodigo(), ev.getTrmNombre());
                select[i++] = item;
            }
            return select;
        } catch (Exception ex) {
            SelectItem[] select = new SelectItem[1];
            SelectItem item = new SelectItem(null, "No existen Tramites");
            select[0] = item;
            return select;
        }
    }

    public String cuentaIngreso() {
        try {
            if (costo) {
                url = "/tramite/cuentaIngreso.jsp";
                cuentaIngresos = cuentaIngresoDeleg.listarParaTramite();
                cuentaIngresosAgregados = new ArrayList<CuentaIngreso>();
            } else {
                url = "/tramite/buscarTDocumTram.jsp";
            }
        } catch (Exception e) {
            mostrarMensaje(e.toString(), e.getMessage(), FacesMessage.SEVERITY_ERROR);
        }
        return "";
    }

    public EnumTipoTramite getTipoTramiteSeleccionado() {
        return tipoTramiteSeleccionado;
    }

    public void setTipoTramiteSeleccionado(EnumTipoTramite tipoTramiteSeleccionado) {
        this.tipoTramiteSeleccionado = tipoTramiteSeleccionado;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public Procedimiento getProcedimiento() {
        return procedimiento;
    }

    public void setProcedimiento(Procedimiento procedimiento) {
        this.procedimiento = procedimiento;
    }

    public String getDescTDoc() {
        return descTDoc;
    }

    public void setDescTDoc(String descTDoc) {
        this.descTDoc = descTDoc;
    }

    public TipoDocumento getTipoDocumento() {
        return tipoDocumento;
    }

    public void setTipoDocumento(TipoDocumento tipoDocumento) {
        this.tipoDocumento = tipoDocumento;
    }

    public List<TipoDocumento> getTipoDocumentos() {
        return tipoDocumentos;
    }

    public void setTipoDocumentos(List<TipoDocumento> tipoDocumentos) {
        this.tipoDocumentos = tipoDocumentos;
    }

    public List<TipoDocumento> getTipoDocumentosAgregados() {
        return tipoDocumentosAgregados;
    }

    public void setTipoDocumentosAgregados(List<TipoDocumento> tipoDocumentosAgregados) {
        this.tipoDocumentosAgregados = tipoDocumentosAgregados;
    }

    public List<Area> getAreas() {
        return areas;
    }

    public void setAreas(List<Area> areas) {
        this.areas = areas;
    }

    public List<Area> getAreasAgregadas() {
        return areasAgregadas;
    }

    public void setAreasAgregadas(List<Area> areasAgregadas) {
        this.areasAgregadas = areasAgregadas;
    }

    public List<Procedimiento> getProcedimientos() {
        return procedimientos;
    }

    public void setProcedimientos(List<Procedimiento> procedimientos) {
        this.procedimientos = procedimientos;
    }
    private boolean hab;
    private boolean cons;
    private boolean obr;
    private final static String habilidad = "Certificado de Habilidad Profesional";
    private final static String construccion = "Certificado de Habilidad de Expediente de Construcción";
    private final static String obras = "Certificado Habilidad Firma de Contrato de Obras Publicas";

    public String getInicio() {
        hab = false;
        cons = false;
        obr = false;
//        errores = new ArrayList<String>();
//        if (!modalCargar) {
//            tramite = new Tramite();
//            tramite.setTrmNombre("");
//            tramites = new ArrayList<Tramite>();
//            listarTramites();
//            if (tramites.size() < 1) {
//                modalAceptar = true;
//            }
//        }
        tramites = new ArrayList<Tramite>();
        Tramite tram;
        tram = new Tramite(habilidad, " ", EnumTipoTramite.Certificado);
        tramites.add(tram);
        tram = new Tramite(construccion, " ", EnumTipoTramite.Certificado);
        tramites.add(tram);
        tram = new Tramite(obras, " ", EnumTipoTramite.Certificado);
        tramites.add(tram);
        return "";
    }

    public String modificarCert() {
        Tramite tram;
        tram = delegado.buscar(tramite.getTrmNombre());
        if (tram != null) {
            tramite = tram;
            cuentaIngresosAgregados = new ArrayList<CuentaIngreso>();
            List<CuentaingresoTramite> cuinTram = ciTramiteDelegado.listarXTramite(tramite);
            for (CuentaingresoTramite cit : cuinTram) {
                cuentaIngresosAgregados.add(cit.getFkCinCodigo());
            }
            cuentaIngresos = cuentaIngresoDeleg.listarParaTramite();
            for (CuentaIngreso ci : cuentaIngresosAgregados) {
                for(CuentaIngreso cit: cuentaIngresos){
                    if(cit.equals(ci)){
                        cit.setSelect(true);
                    }
                }
            }
            return "editar";
        } else {
            mostrarMensaje("", "El Certificado no existe primero debe configurarlo", FacesMessage.SEVERITY_ERROR);
            return "";
        }
    }

    public String configurarCert() {
        Tramite tram;
        tram = delegado.buscar(tramite.getTrmNombre());
        if (tram == null) {
            cuentaIngresos = cuentaIngresoDeleg.listarParaTramite();
            cuentaIngresosAgregados = new ArrayList<CuentaIngreso>();
            return "conf";
        } else {
            mostrarMensaje("", "El Certificado ya existe solo puede modificarlo", FacesMessage.SEVERITY_ERROR);
            return "";
        }
    }
    
    public String editarCert() {
        delegado.edit(tramite);
        List<CuentaingresoTramite> cuinTramites= new ArrayList<CuentaingresoTramite>();
        cuinTramites=ciTramiteDelegado.listarXTramite(tramite);
        for (CuentaingresoTramite cit : cuinTramites) {
            ciTramiteDelegado.remove(cit);
        }
        for (CuentaIngreso ci : cuentaIngresos) {
            if (ci.getSelect()) {
                ciTramiteDelegado.create(new CuentaingresoTramite(ci, tramite, true, false));
            }
        }
        mostrarMensaje("", "La edicion se completo con exito", FacesMessage.SEVERITY_INFO);
        return "#";
    }

    public String grabarCert() {
        delegado.create(tramite);
        procedimiento = new Procedimiento("Inicio", true, true, tramite);
        delegadoProc.create(procedimiento);
        for (CuentaIngreso ci : cuentaIngresos) {
            if (ci.getSelect()) {
                ciTramiteDelegado.create(new CuentaingresoTramite(ci, tramite, true, false));
            }
        }
        return "#";
    }

    public void setInicio(String i) {
    }

    private void cargarTramites() {
        Tramite tram;
        List<Tramite> tramitesEliminar;
        tramitesEliminar = new ArrayList<Tramite>();
        tramitesCargar = new ArrayList<Tramite>();
        tram = new Tramite("Solicitud de Constancia de no adeudo");
        tramitesCargar.add(tram);
        tram = new Tramite("Solicitud de Constancia de trámite de colegiatura");
        tramitesCargar.add(tram);
        tram = new Tramite("Solicitud de Constancia de participación en Evento");
        tramitesCargar.add(tram);
        tram = new Tramite("Solicitud de Certificado de Habilidad Profesional");
        tramitesCargar.add(tram);
        tram = new Tramite("Solicitud de Certificado de Habilitación de Proyectos");
        tramitesCargar.add(tram);
        tram = new Tramite("Solicitud de Certificado de Habilitación de Obras Públicas");
        tramitesCargar.add(tram);
        tram = new Tramite("Solicitud de apertura de Evento Interno");
        tramitesCargar.add(tram);
        tram = new Tramite("Solicitud de fraccionamiento de deuda");
        tramitesCargar.add(tram);
        tram = new Tramite("Solicitud de Exoneración de cuotas");
        tramitesCargar.add(tram);
        tram = new Tramite("Solicitud de Incorporación de transferencia");
        tramitesCargar.add(tram);
        tram = new Tramite("Solicitud de Duplicado de Carnet (Perdida)");
        tramitesCargar.add(tram);
        tram = new Tramite("Solicitud de Duplicado de Carnet (Renovación)");
        tramitesCargar.add(tram);
        tram = new Tramite("Solicitud Perito");
        tramitesCargar.add(tram);
        for (Tramite trami : tramites) {
            tramitesEliminar.add(new Tramite(trami.getTrmNombre()));
        }
        for (Tramite trami : tramitesEliminar) {
            tramitesCargar.remove(trami);
        }
    }

    public String aceptarModal() {
        cargarTramites();
        modalAceptar = false;
        modalCargar = true;
        try {
            ControladorAbstracto.getResponse().sendRedirect("/tramite/faces/tramite/buscar.jsp");
        } catch (IOException ex) {
            Logger.getLogger(TramitesController.class.getName()).log(Level.SEVERE, null, ex);
        }
        return "";
    }

    public String cancelarModal() {
        modalAceptar = false;
        return "";
    }

    public String aceptarModalC() {

        modalCargar = false;
        return "";
    }

    private void cargarResponsables(Procedimiento proc) {
        ResponsableProc res;
        Area area;

        if (proc.getProNombre().equals("1")) {
            area = areaDelegado.buscar("Secretaria General");
            if (area != null) {
                res = new ResponsableProc(delegadoCargo.buscarXArea("", area), new Date(), true);
                if (res.getFkCodigocargo() == null) {
                    errores.set(errores.size() - 1, errores.get(errores.size() - 1) + ": No se encuentra el Cargo ");
                }
            } else {
                errores.set(errores.size() - 1, errores.get(errores.size() - 1) + ": No se encuentra el Area Secretaria General");
            }
        }
    }

    private void cargarProcedimientos(Tramite tram) {
        Procedimiento proc;

        if (tram.getTrmNombre().equals("1")) {
            errores.add(tram.getTrmNombre());
            proc = new Procedimiento(tram.getTrmNombre() + "_Inicio", true, true);
        }
    }

    public List<Tramite> getTramites() {
        return tramites;
    }

    public String agregarESeleccionados() {
        Area areaTemp = new Area();
        areaTemp.setCodigo(-1);
        areasAgregadas.remove(areaTemp);
        Iterator iterator = areaSelecionadas.getKeys();
        while (iterator.hasNext()) {
            Integer key = (Integer) iterator.next();
            areaTemp = areas.get(key);
            areaTemp.setCodigo(++codigo);
            areaTemp.setPadre(areaPadre);
            areasGrabar.add(areaTemp);
            areasAgregadas.add(areaTemp);
        }
        for (Area ar : areasAgregadas) {
            areas.remove(ar);
        }
        if (!areaPadre.getAreNombre().equals("Inicio")) {
            areaTemp = new Area();
            areaTemp.setCodigo(-1);
            areasAgregadas.add(areaTemp);
        }
        return "";
    }

    public String agregarETodos() {
        try {
            for (Area ar : areas) {
                Area areaTemp = ar;
                areaTemp.setCodigo(++codigo);
                areaTemp.setPadre(areaPadre);
                areasGrabar.add(areaTemp);
                areasAgregadas.add(areaTemp);
            }
            areas.clear();
            if (!areaPadre.getAreNombre().equals("Inicio")) {
                Area areaTemp = new Area();
                areaTemp.setCodigo(-1);
                areasAgregadas.add(areaTemp);
            }
        } catch (Exception e) {
        }
        return "";
    }

    public String quitarETodos() {
        try {
            areasEliminar = new ArrayList<Area>();
            eliminados = true;
            for (Area ar : areasAgregadas) {
                if (ar.getCodigo() > 0) {
                    eliminarProcedimientos(ar);
                }
            }
            if (eliminados) {
                areasAgregadas.clear();
                if (!areaPadre.getAreNombre().equals("Inicio")) {
                    Area areaTemp = new Area();
                    areaTemp.setCodigo(-1);
                    areasAgregadas.add(areaTemp);
                }
            } else {
                quitarProcedimientos();
                modalAceptar = true;
            }

        } catch (Exception e) {
        }
        return "";
    }

    private void quitarProcedimientos() {
        for (Area ar : areas) {
            areasAgregadas.remove(ar);
        }
    }

    private boolean eliminarRecursivo(int indice) {
        int cantidad = areasGrabar.size();
        for (int i = 0; i < cantidad; i++) {
            if (areasGrabar.get(i).getPadre().getCodigo() == areasGrabar.get(indice).getCodigo()) {
                eliminarRecursivo(i--);
                cantidad--;
            }
        }
        areasGrabar.remove(indice);
        return true;
    }

    public String eliminarModal() {
        for (Area ar : areasEliminar) {
            int cantidad = areasGrabar.size();
            for (int i = 0; i < cantidad; i++) {
                if (areasGrabar.get(i).getCodigo() == ar.getCodigo()) {
                    eliminarRecursivo(i);
                    areas.add(ar);
                    areasAgregadas.remove(ar);
                    break;
                }
            }
        }
        return "";
    }

    private void eliminarProcedimientos(Area ar) {
        int cantidad = areasGrabar.size();
        int indice = -1;
        boolean band = true;
        for (int i = 0; i < cantidad; i++) {
            if (areasGrabar.get(i).getPadre().getCodigo() == ar.getCodigo()) {
                areasEliminar.add(ar);
                eliminados = false;
                band = false;
            }
            if (areasGrabar.get(i).getCodigo() == ar.getCodigo()) {
                indice = i;
            }
        }
        if (band) {
            areasGrabar.remove(indice);
            areas.add(ar);
        }
    }

    public String quitarESeleccionados() {
        try {
            areasEliminar = new ArrayList<Area>();
            eliminados = true;
            Iterator iterator = areaSelecionadasAg.getKeys();
            while (iterator.hasNext()) {
                Integer key = (Integer) iterator.next();
                Area areaTemp = areasAgregadas.get(key);
                if (areaTemp.getCodigo() > 0) {
                    eliminarProcedimientos(areaTemp);
                }
            }
            quitarProcedimientos();
            if (!eliminados) {
                modalAceptar = true;
            }
        } catch (Exception e) {
        }
        return "";
    }

    public String configurar() {
//        try {
        if (areaSeleccionada.getCargoCollection().isEmpty()) {
            mostrarMensaje("Cargos: ", "No Existen Cargos para esta Area, sera eliminada", FacesMessage.SEVERITY_ERROR);
            int cantidad = areasGrabar.size();

            for (int i = 0; i < cantidad; i++) {
                if (areasGrabar.get(i).getCodigo() == areaSeleccionada.getCodigo()) {
                    areasGrabar.remove(i);
                    areas.add(areaSeleccionada);
                    areasAgregadas.remove(areaSeleccionada);
                }
            }
            return "";
        } else if (areaSeleccionada.getDocumentos() == null) {
            areaSeleccionada.setDocumentos(new ArrayList<TipoDocumento>());
            for (TipoDocumento t : tipoDocumentosAgregados) {
                areaSeleccionada.getDocumentos().add(new TipoDocumento(t.getTdoCodigo(), t.getTdoDesc()));
            }
        }
//        } catch (Exception e) {
//            mostrarMensaje(e.toString(), e.getMessage(), FacesMessage.SEVERITY_ERROR);
//        }
        return "conf";
    }

    public String aceptarConf() {
        return "proced";
    }

    public String agregarHijo() {
        if (validarProcedimiento()) {
            listarAreas();
            areasAgregadas.clear();
            int cantidad = areasGrabar.size();

            for (Area ar : areasGrabar) {
                if (ar.getPadre().getCodigo() == areaPadre.getCodigo() && !ar.getAreNombre().equals("Inicio")) {
                    areasAgregadas.add(ar);
                }
            }

            for (Area ar : areasAgregadas) {
                for (int i = 0; i < cantidad; i++) {
                    if (areas.get(i).equals(ar)) {
                        areas.remove(i--);
                        cantidad--;
                    }
                }
            }
            if (!areaPadre.getAreNombre().equals("Inicio")) {
                Area areaTemp = new Area();
                areaTemp.setCodigo(-1);
                areasAgregadas.add(areaTemp);
            }
            areas.remove(areaPadre);
        } else {
            areaPadre = areaPadre.getPadre();
        }
        return "";
    }

    public String retroceder() {
        if (validarProcedimiento()) {
            areaPadre = areaPadre.getPadre();
            return agregarHijo();
        }
        return "";
    }

    private boolean validarProcedimiento() {
        for (Area ar : areasAgregadas) {
            boolean band = false;
            if (ar.getCargoCollection() == null && ar.getCodigo() != -1) {
                mostrarMensaje("Configurar Procedimiento: ", "Faltan Procedimientos por Configurar", FacesMessage.SEVERITY_ERROR);
                return false;
            } else if (ar.getCodigo() != -1) {
                for (Cargo car : ar.getCargoCollection()) {
                    if (car.isSeleccionado()) {
                        band = true;
                    }
                }
                if (!band) {
                    mostrarMensaje("Configurar Procedimiento: ", "Faltan Procedimientos por Configurar", FacesMessage.SEVERITY_ERROR);
                    return false;
                }
            }
        }
        return true;
    }

    public String grabar() {
        if (validarProcedimiento()) {
            delegado.create(getTramite());
            if (costo) {
                for (CuentaIngreso ci : cuentaIngresosAgregados) {
                    CuentaingresoTramite cuenta = new CuentaingresoTramite(ci, tramite, true, false);
                    ciTramiteDelegado.create(cuenta);
                }
            }
            grabarProcedimientos();
            return "buscar";
        }
        return "";
    }

    private boolean grabarRecursivo(Area area, Procedimiento padre) {
        for (Area ar : areasGrabar) {
            if (ar.getPadre().getCodigo() == area.getCodigo() && !ar.getAreNombre().equals("Inicio")) {
                procedimiento = new Procedimiento(ar.getAreNombre(), ar.isObligatorio(), ar.isRespAut(), tramite, padre);
                delegadoProc.create(procedimiento);
                for (TipoDocumento doc : ar.getDocumentos()) {
                    if (doc.getSeleccionado()) {
                        delegadoDocR.create(new DocRequerido(procedimiento, doc, doc.isSoloLectura()));
                    }
                }
                for (Cargo car : ar.getCargoCollection()) {
                    if (car.isSeleccionado()) {
                        delegadoResp.create(new ResponsableProc(car, procedimiento, new Date(), true));
                    }
                }
                grabarRecursivo(ar, procedimiento);
            }
        }
        return true;
    }

    private void grabarProcedimientos() {
//        areaPadre.setAreNombre("Inicio");
//        areaPadre.setCodigo(0);
        areaPadre = new Area();
        areaPadre.setAreNombre("Inicio");
        areaPadre.setCodigo(0);
        procedimiento = new Procedimiento(areaPadre.getAreNombre(), true, true, tramite);
        delegadoProc.create(procedimiento);
        for (TipoDocumento tdo : tipoDocumentosAgregados) {
            delegadoDocR.create(new DocRequerido(procedimiento, tdo, true));
        }
        grabarRecursivo(areaPadre, procedimiento);
    }

    public String nuevo() {
        tramite=new Tramite();
        url = "/tramite/buscarTDocumTram.jsp";
        tipoDocumentos = new ArrayList<TipoDocumento>();
        listarTDocumentos();
        tipoDocumentosAgregados = new ArrayList<TipoDocumento>();
        areas = new ArrayList<Area>();
        listarAreas();
        areasAgregadas = new ArrayList<Area>();
        areasGrabar = new ArrayList<Area>();
        areaSelecionadas = new SimpleSelection();
        areaSelecionadasAg = new SimpleSelection();
        areaPadre = new Area();
        areaPadre.setAreNombre("Inicio");
        areaPadre.setPadre(new Area());
        areasGrabar.add(areaPadre);
        codigo = 0;
        contador = 0;
        return "nuevo";
    }

    private void listarTramites() {
        tramites = delegado.buscarPorNombre(tramite.getTrmNombre());
    }

    public Tramite buscarXId(Long id){
        return delegado.find(id);
    }

    public String buscar() {
        listarTramites();
        return null;
    }

    public void listarAreas() {
        setAreas(areaDelegado.findAll());
    }

    public void mostrarMensaje(String resumen, String detalle, FacesMessage.Severity severidad) {
        try {
            FacesMessage fm = new FacesMessage(severidad, resumen, detalle);
            FacesContext.getCurrentInstance().addMessage(fm.toString(), fm);
        } catch (Exception e) {
            FacesMessage fm = new FacesMessage(FacesMessage.SEVERITY_ERROR, e.getMessage(), e.getMessage());
            FacesContext.getCurrentInstance().addMessage(fm.toString(), fm);
        }
    }

    public String removeTipDoc() {
        Iterator iterator = tipDocSelecionadas.getKeys();
        while (iterator.hasNext()) {
            Integer key = (Integer) iterator.next();

//            areaTemp = areas.get(key);
//            areaTemp.setCodigo(++codigo);
//            areaTemp.setPadre(areaPadre);
//            areasGrabar.add(areaTemp);
//            areasAgregadas.add(areaTemp);
        }

        return "";
    }

    public String buscarProc() {
//        if (tipoDocumentosAgregados.size() < 1) {
//            tipoDocumentosAgregados.add(new TipoDocumento());
//        }
        return "next";
    }

    public String buscarTipDoc() {
        if (cuentaIngresosAgregados.size() < 1) {
            mostrarMensaje("Error:", " Debe seleccionar por lo menos una Cuenta de Ingreso", FacesMessage.SEVERITY_ERROR);
            return "";
        }
        return "next";
    }

    public String getNavegar() {
        try {
            FacesContext.getCurrentInstance().getApplication().getNavigationHandler().handleNavigation(FacesContext.getCurrentInstance(), null, "next");
        } catch (Exception ex) {
            Logger.getLogger(TramitesController.class.getName()).log(Level.SEVERE, null, ex);
        }
        return "buscar";
    }

    public String regresarTramite() {
        return "nuevo";
    }

    private void listarTDocumentos() {
        tipoDocumentos = delegadoTDoc.buscarTipoDocumento(descTDoc);
    }

//    public String buscarTDoc() {
//        listarTDocumentos();
//        return null;
//    }
    public String editar() {
        editar = false;
        ciTramites = ciTramiteDelegado.listarXTramite(tramite);
        if (ciTramites != null) {
            costo = true;
            cuentaIngreso();
            for (CuentaingresoTramite ci : ciTramites) {
                if (cuentaIngresos.contains(ci.getFkCinCodigo())) {
                    cuentaIngresos.remove(ci.getFkCinCodigo());
                    cuentaIngresosAgregados.add(ci.getFkCinCodigo());
                }
            }
        }
        docRequeridos = delegadoDocR.listarDocumentoXTramite(tramite);
        tipoDocumentos = delegadoTDoc.findAll();
        tipoDocumentosAgregados = new ArrayList<TipoDocumento>();
        if (docRequeridos != null) {
            for (DocRequerido doc : docRequeridos) {
                if (tipoDocumentos.contains(doc.getFkTdoCodigo())) {
                    tipoDocumentos.remove(doc.getFkTdoCodigo());
                    tipoDocumentosAgregados.add(doc.getFkTdoCodigo());
                }
            }
        }
        procedimiento = delegadoProc.buscarInicioXTramite(tramite);
        Operacion ope = new Operacion();
        ope.setFkProCodigo(procedimiento);
        Transaccion tran = new Transaccion();
        tran.setFkTrmCodigo(tramite);
        tran.setOperacionActiva(ope);
        procedimientos = delegadoProc.nextProced(tran);
        areas = areaDelegado.findAll();
        areasAgregadas = new ArrayList<Area>();
        if (procedimientos != null) {
            for (Procedimiento pro : procedimientos) {
                areaSeleccionada = areaDelegado.buscar(pro.getResponsableProcCollection().get(0).getFkCodigocargo());
                if (areas.contains(areaSeleccionada)) {
                    areas.remove(areaSeleccionada);
                    areasAgregadas.add(areaSeleccionada);
                }
            }
        }
        return "editar";
    }

    public String actualizar() {
        delegado.edit(getTramite());
        return "buscar";
    }

    public boolean isModalAceptar() {
        return modalAceptar;
    }

    public boolean isModalCargar() {
        return modalCargar;
    }

    public List<Tramite> getTramitesCargar() {
        return tramitesCargar;
    }

    public SimpleSelection getAreaSelecionadas() {
        return areaSelecionadas;
    }

    public void setAreaSelecionadas(SimpleSelection areaSelecionadas) {
        this.areaSelecionadas = areaSelecionadas;
    }

    public SimpleSelection getAreaSelecionadasAg() {
        return areaSelecionadasAg;
    }

    public void setAreaSelecionadasAg(SimpleSelection areaSelecionadasAg) {
        this.areaSelecionadasAg = areaSelecionadasAg;
    }

    public Area getAreaPadre() {
        return areaPadre;
    }

    public void setAreaPadre(Area areaPadre) {
        this.areaPadre = areaPadre;
    }

    public Area getAreaSeleccionada() {
        return areaSeleccionada;
    }

    public void setAreaSeleccionada(Area areaSeleccionada) {
        this.areaSeleccionada = areaSeleccionada;
    }

    /**
     * @return the url
     */
    public String getUrl() {
        return url;
    }

    /**
     * @param url the url to set
     */
    public void setUrl(String url) {
        this.url = url;
    }

    /**
     * @return the costo
     */
    public boolean isCosto() {
        return costo;
    }

    /**
     * @param costo the costo to set
     */
    public void setCosto(boolean costo) {
        this.costo = costo;
        cuentaIngreso();
    }

    /**
     * @return the cuentaIngresos
     */
    public List<CuentaIngreso> getCuentaIngresos() {
        return cuentaIngresos;
    }

    /**
     * @param cuentaIngresos the cuentaIngresos to set
     */
    public void setCuentaIngresos(List<CuentaIngreso> cuentaIngresos) {
        this.cuentaIngresos = cuentaIngresos;
    }

    /**
     * @return the cuentaIngresosAgregados
     */
    public List<CuentaIngreso> getCuentaIngresosAgregados() {
        return cuentaIngresosAgregados;
    }

    /**
     * @param cuentaIngresosAgregados the cuentaIngresosAgregados to set
     */
    public void setCuentaIngresosAgregados(List<CuentaIngreso> cuentaIngresosAgregados) {
        this.cuentaIngresosAgregados = cuentaIngresosAgregados;
    }

    /**
     * @return the tipDocSelecionadas
     */
    public SimpleSelection getTipDocSelecionadas() {
        return tipDocSelecionadas;
    }

    /**
     * @param tipDocSelecionadas the tipDocSelecionadas to set
     */
    public void setTipDocSelecionadas(SimpleSelection tipDocSelecionadas) {
        this.tipDocSelecionadas = tipDocSelecionadas;
    }

    /**
     * @return the tipDocSelecionadasAg
     */
    public SimpleSelection getTipDocSelecionadasAg() {
        return tipDocSelecionadasAg;
    }

    /**
     * @param tipDocSelecionadasAg the tipDocSelecionadasAg to set
     */
    public void setTipDocSelecionadasAg(SimpleSelection tipDocSelecionadasAg) {
        this.tipDocSelecionadasAg = tipDocSelecionadasAg;
    }
}
